#Import necessary libraries
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import warnings
from sklearn import preprocessing
warnings.filterwarnings('ignore')

# Load the dataset using pandas and storing them in a dataframe variable
df = pd.read_csv('Cars.csv')

# Displaying the first few rows of the dataframe
df.head()

#Checking the statistical summary of the dataframe
df.describe()

#Checking the data types and non-null values in the dataframe
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8128 entries, 0 to 8127
Data columns (total 13 columns):
 #   Column         Non-Null Count  Dtype  
---  ------         --------------  -----  
 0   name           8128 non-null   object 
 1   year           8128 non-null   int64  
 2   selling_price  8128 non-null   int64  
 3   km_driven      8128 non-null   int64  
 4   fuel           8128 non-null   object 
 5   seller_type    8128 non-null   object 
 6   transmission   8128 non-null   object 
 7   owner          8128 non-null   object 
 8   mileage        7907 non-null   object 
 9   engine         7907 non-null   object 
 10  max_power      7913 non-null   object 
 11  torque         7906 non-null   object 
 12  seats          7907 non-null   float64
dtypes: float64(1), int64(3), object(9)
memory usage: 825.6+ KB

#Checking the number of rows and columns in the dataframe
df.shape

(8128, 13)

#Checking the column names in the dataframe
df.columns

Index(['name', 'year', 'selling_price', 'km_driven', 'fuel', 'seller_type',
       'transmission', 'owner', 'mileage', 'engine', 'max_power', 'torque',
       'seats'],
      dtype='object')

#Checking for unique values in "owner" column
df['owner'].unique()

array(['First Owner', 'Second Owner', 'Third Owner',
       'Fourth & Above Owner', 'Test Drive Car'], dtype=object)

#Mapping the owner column to numerical values.
ownermap = {                  
    "First Owner":1,
    "Second Owner":2, 
    "Third Owner":3, 
    "Fourth & Above Owner":4, 
    "Test Drive Car":5
    }

#Checking if the owner column exists in the dataframe and then mapping it.
if 'owner' in df.columns:      
    df['owner'] = df['owner'].map(ownermap)

#Checking if mapping is done correctly
df.owner.unique()

array([1, 2, 3, 4, 5])

#Getting the count of unique values in the 'Fuel' column
df['fuel'].unique()

array(['Diesel', 'Petrol', 'LPG', 'CNG'], dtype=object)

#Storing the unique values to remove in an array
fuel_to_remove = ['CNG', 'LPG']

#Removing the unwanted fuel types from the dataframe
df = df[~df['fuel'].isin(fuel_to_remove)]

#checking if the unwanted fuel types are removed
df['fuel'].unique()

array(['Diesel', 'Petrol'], dtype=object)

#Getting the values of mileage column
df['mileage'].head()

0     23.4 kmpl
1    21.14 kmpl
2     17.7 kmpl
3     23.0 kmpl
4     16.1 kmpl
Name: mileage, dtype: object

#Removing the "kmpl" from the mileage column
df['mileage']= df['mileage'].str.split( ).str[0]

#Converting the mileage column to float type
df['mileage'] = df['mileage'].astype(float)

#Checking if the conversation is done correctly
df['mileage'].dtype

dtype('float64')

#Getting the values of 'engine' feature column
df['engine'].head()

0    1248 CC
1    1498 CC
2    1497 CC
3    1396 CC
4    1298 CC
Name: engine, dtype: object

#Removing the 'CC' from the engine column using str.split() method
df['engine'] = df['engine'].str.split( ).str[0]

#Verifying the changes in the engine column
df['engine'].head()

0    1248
1    1498
2    1497
3    1396
4    1298
Name: engine, dtype: object

#converting the data type of engine column to float
df['engine'] = df['engine'].astype(float)

#verifying the data type of engine column
df['engine'].dtype

dtype('float64')

#Getting the values of the column 'max_power'
df['max_power'].head()

0        74 bhp
1    103.52 bhp
2        78 bhp
3        90 bhp
4      88.2 bhp
Name: max_power, dtype: object

#Removing the 'bhp' from the max_power column using str.split() method
df['max_power'] = df['max_power'].str.split( ).str[0]

#Converting the data type of max_power column to float
df['max_power'] = df['max_power'].astype(float)

#Verifying the changes
df['engine'].head()

0    1248.0
1    1498.0
2    1497.0
3    1396.0
4    1298.0
Name: engine, dtype: float64

#Converting the mileage column to float type
df['mileage'] = df['mileage'].astype(float)

#Verifying the changes
df['engine'].dtypes

dtype('float64')

df.columns

Index(['name', 'year', 'selling_price', 'km_driven', 'fuel', 'seller_type',
       'transmission', 'owner', 'mileage', 'engine', 'max_power', 'torque',
       'seats'],
      dtype='object')

#Renaming the column 'name' to 'brand'
df.rename(columns={'name':'brand'}, inplace=True)
#checking the changes
df.columns

Index(['brand', 'year', 'selling_price', 'km_driven', 'fuel', 'seller_type',
       'transmission', 'owner', 'mileage', 'engine', 'max_power', 'torque',
       'seats'],
      dtype='object')

#Getting information about the column 'brand'
df['brand'].head()

0          Maruti Swift Dzire VDI
1    Skoda Rapid 1.5 TDI Ambition
2        Honda City 2017-2020 EXi
3       Hyundai i20 Sportz Diesel
4          Maruti Swift VXI BSIII
Name: brand, dtype: object

#Only taking the first word from the brand column by using the str.split() method
df['brand'] = df['brand'].str.split( ).str[0]

#Verifying the changes
df['brand'].head()

0     Maruti
1      Skoda
2      Honda
3    Hyundai
4     Maruti
Name: brand, dtype: object

#Removing the feature 'torque' from the dataframe using the drop() method
df = df.drop(['torque'], axis=1)

#Removing the 'Owner=5' from the dataframe using the query() method
df = df.query("owner != '5'")

#Verifying the changes on the owner column
df['owner'].unique()

array([1, 2, 3, 4, 5])

#Checking the cleaned dataframe
df.head()

#Importing the LabelEncoder from sklearn library
from sklearn.preprocessing import LabelEncoder

#Initializing the LabelEncoder
label_encoder_brand = LabelEncoder()
label_encoder_fuel = LabelEncoder()
label_encoder_seller_type = LabelEncoder()
label_encoder_transmission = LabelEncoder()

#Transforming the categorical columns using the fit_transform() method
df['brand'] = label_encoder_brand.fit_transform(df['brand'])
original_brands = label_encoder_brand.classes_.tolist()
df['fuel'] = label_encoder_fuel.fit_transform(df['fuel'])
df['seller_type'] = label_encoder_seller_type.fit_transform(df['seller_type'])      
df['transmission'] = label_encoder_transmission.fit_transform(df['transmission'])

#Checking for the changes made
df.head()

#Creating a csv of the encoded data set.
df.to_csv('le_cars_data.csv', sep = ',', index=False, encoding='utf-8 ')

#Seperating the numerical and categorical columns from the dataframe
#Excluding the column 'selling_price' from the numerical columns using df.loc method and storing in a variable 

df_copy = df.loc[:, df.columns != 'selling_price']

#Seperating the numerical and categorical columns from the dataframe

num_cols = df_copy.select_dtypes(include=['int64', 'float64'])
cat_cols = df_copy.select_dtypes(exclude=['int64', 'float64'])

#Verifying the changes made to the dataset
num_cols.columns, cat_cols.columns

(Index(['brand', 'year', 'km_driven', 'fuel', 'seller_type', 'transmission',
        'owner', 'mileage', 'engine', 'max_power', 'seats'],
       dtype='object'),
 Index([], dtype='object'))

#Analysing the count of all nummerical colums using the distribution plot
for col in num_cols.columns:
    sns.displot(df, x=df[col])

#Plotting the features in the scatter plot to see the relationship between the features and selling_price by keeping fuel as hue
sns.scatterplot(x=df['brand'], y=df['selling_price'], hue=df['fuel'])

<Axes: xlabel='brand', ylabel='selling_price'>

sns.scatterplot(x=df['year'], y=df['selling_price'], hue=df['fuel'])

<Axes: xlabel='year', ylabel='selling_price'>

sns.scatterplot(x=df['km_driven'], y=df['selling_price'], hue=df['fuel'])

<Axes: xlabel='km_driven', ylabel='selling_price'>

sns.scatterplot(x=df['mileage'], y=df['selling_price'], hue=df['fuel'])

<Axes: xlabel='mileage', ylabel='selling_price'>

sns.scatterplot(x=df['engine'], y=df['selling_price'], hue=df['fuel'])

<Axes: xlabel='engine', ylabel='selling_price'>

sns.scatterplot(x=df['max_power'], y=df['selling_price'], hue=df['fuel'])

<Axes: xlabel='max_power', ylabel='selling_price'>

plt.figure(figsize=(10,8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
plt.show()

df['selling_price'] = pd.qcut(x=df['selling_price'], q=4, labels=range(0, 4))
df.head()

#The important features that were selected based on the correlation and ppscore matrix are stored in variable X

# Main features = max power, mileage, engine and brand

X = df[['max_power', 'mileage', 'year', 'brand']]

#Selling price is stored in variable Y, which is the target variable. Here, we have logarithmically transformed the selling_price column to ensure stability of prediction.
y = df['selling_price']

k = len(set(y))
k

4

from sklearn.model_selection import train_test_split
#Splitting the dataset into training and testing sets using train_test_split() method
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=40)

#Checking for null values in the training and testing sets
X_train[['max_power', 'mileage', 'year', 'brand']].isnull().sum()

max_power    146
mileage      151
year           0
brand          0
dtype: int64

X_test[['max_power', 'mileage', 'year', 'brand']].isnull().sum()

max_power    62
mileage      63
year          0
brand         0
dtype: int64

#Checking for null values in y_train
y_train.isnull().sum()

np.int64(0)

#Checking for null values in y_train
y_test.isnull().sum()

np.int64(0)

X_train['max_power'].median() #Finding the median of max_power because the distribution is right skewed and using mean to fill the null values will affect the distribution of the data.

np.float64(83.1)

X_train['mileage'].mean() #Finding the mean of mileage because the distribution is nearly normal and mean can be used to fill the null values.

np.float64(19.35297697368421)

X_test['max_power'].median()

np.float64(82.0)

X_test['mileage'].mean()

np.float64(19.47756710694504)

X_train['max_power'].fillna(X_train['max_power'].median(), inplace=True)
X_train['mileage'].fillna(X_train['mileage'].mean(), inplace=True)
X_test['max_power'].fillna(X_test['max_power'].median(), inplace=True)
X_test['mileage'].fillna(X_test['mileage'].mean(), inplace=True)

#Verifying if the null values are filled in training set    
X_train[['max_power', 'mileage', 'brand', 'year']].isnull().sum()

max_power    0
mileage      0
brand        0
year         0
dtype: int64

#Verifying if the null values are filled in test set    
X_test[['max_power', 'mileage', 'brand', 'year']].isnull().sum()

max_power    0
mileage      0
brand        0
year         0
dtype: int64

#Verifying if the null values are filled in y_train and y_test
y_train.isnull().sum(), y_test.isnull().sum()

(np.int64(0), np.int64(0))

#Checking the outliers in the training set using box plot 
#Creating a dictionary to store the columns and their respective values

col_dict = {'max_power': 1, 'mileage': 2, 'year': 3, 'brand': 4}

#Using boxplot to visualize the outliers in the training set
plt.figure(figsize=(15,20))
for i, col in col_dict.items():
    plt.subplot(4,2,col)
    sns.boxplot(X_train[i])
    plt.title(f'Box plot of {i}')
plt.show()

#To check the impact of outliers on the efficiency of the model, we will define a function to calculate the outliers of each feature using the IQR method

def calculate_outliers(col, data=X_train):
    q75 = np.percentile(data[col], 75)
    q25 = np.percentile(data[col], 25)
    iqr = q75 - q25
    min_val = q25 - (1.5 * iqr)
    max_val = q75 + (1.5 * iqr)

    calculate_outliers = len(np.where((data[col] < min_val) | (data[col] > max_val))[0])
    percentage_outliers = round(calculate_outliers / len(data) * 100, 2)

    if calculate_outliers > 0:
        print(f'Feature {col} has {calculate_outliers} outliers which is {percentage_outliers}% of the data')
    else:
        print(f'Feature {col} has no outliers')

for col in X_train.columns:
    calculate_outliers(col)

Feature max_power has 412 outliers which is 7.33% of the data
Feature mileage has 13 outliers which is 0.23% of the data
Feature year has 55 outliers which is 0.98% of the data
Feature brand has no outliers

#Importing the library from sklearn for scaling the features, excluding the categorical features

from sklearn.preprocessing import StandardScaler
num_cols = ['max_power', 'mileage', 'year']
scaler = StandardScaler()
X_train[num_cols] = scaler.fit_transform(X_train[num_cols])
X_test[num_cols] = scaler.transform(X_test[num_cols])

#Verifying the changes made
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

(5623, 4)
(2410, 4)
(5623,)
(2410,)

#Encoding of Y_train
Y_train_encoded = pd.get_dummies(y_train)

X_train = X_train.to_numpy()
X_test  = X_test.to_numpy()
Y_train_encoded = Y_train_encoded.to_numpy()
y_test  = y_test.to_numpy()

#Checking the shape
print("Shape of X_train: ", X_train.shape)
print("Shape of X_test: ", X_test.shape)
print("Shape of y_train: ", Y_train_encoded.shape)
print("Shape of y_test: ", y_test.shape)

Shape of X_train:  (5623, 4)
Shape of X_test:  (2410, 4)
Shape of y_train:  (5623, 4)
Shape of y_test:  (2410,)

import time
from sklearn.metrics import classification_report
import mlflow
import os

os.environ["MLFLOW_TRACKING_USERNAME"] = "admin"
os.environ["MLFLOW_TRACKING_PASSWORD"] = "password"

mlflow.set_tracking_uri("https://mlflow.ml.brain.cs.ait.ac.th/")
mlflow.set_experiment("st126222-a3")

<Experiment: artifact_location='mlflow-artifacts:/442617570942485080', creation_time=1759469947454, experiment_id='442617570942485080', last_update_time=1759469947454, lifecycle_stage='active', name='st126222-a3', tags={'mlflow.experimentKind': 'custom_model_development'}>

class LogisticRegression:

    def __init__(self, regularization, k, n, method, alpha=0.001, max_iter=5000):
        self.regularization = regularization
        self.k = int(k)
        self.n = int(n)
        self.alpha = alpha
        self.max_iter = max_iter
        self.method = method
        self.W = None  # Will be initialized later
        self.losses = []

    def fit(self, X, Y):
        self.W = np.random.rand(self.n, self.k)
        params = {
            "reg": type(self).__name__,
            "method": self.method,
            "k": int(self.k),
            "n": int(self.n),
            "alpha": self.alpha,
            "max_iter": self.max_iter
        }
        mlflow.log_params(params=params)

        if self.method == "batch":
            start_time = time.time()
            for i in range(self.max_iter):
                loss, grad = self.gradient(X, Y)
                self.losses.append(loss)
                self.W = self.W - self.alpha * grad
                if i % 500 == 0:
                    print(f"Loss at iteration {i}", loss)
                    mlflow.log_metric(key="train_loss", value=loss, step=i)
            print(f"time taken: {time.time() - start_time}")

        elif self.method == "minibatch":
            start_time = time.time()
            batch_size = int(0.3 * X.shape[0])
            for i in range(self.max_iter):
                ix = np.random.randint(0, X.shape[0])  # With replacement
                batch_X = X[ix:ix + batch_size]
                batch_Y = Y[ix:ix + batch_size]
                loss, grad = self.gradient(batch_X, batch_Y)
                self.losses.append(loss)
                self.W = self.W - self.alpha * grad
                if i % 500 == 0:
                    print(f"Loss at iteration {i}", loss)
                    mlflow.log_metric(key="train_loss", value=loss, step=i)
            print(f"time taken: {time.time() - start_time}")

        elif self.method == "sto":
            start_time = time.time()
            list_of_used_ix = []
            for i in range(self.max_iter):
                idx = np.random.randint(X.shape[0])
                while i in list_of_used_ix:
                    idx = np.random.randint(X.shape[0])
                X_train = X[idx, :].reshape(1, -1)
                Y_train = Y[idx]
                loss, grad = self.gradient(X_train, Y_train)
                self.losses.append(loss)
                self.W = self.W - self.alpha * grad

                list_of_used_ix.append(i)
                if len(list_of_used_ix) == X.shape[0]:
                    list_of_used_ix = []
                if i % 500 == 0:
                    print(f"Loss at iteration {i}", loss)
                    mlflow.log_metric(key="train_loss", value=loss, step=i)
            print(f"time taken: {time.time() - start_time}")

        else:
            raise ValueError('Method must be one of the followings: "batch", "minibatch" or "sto".')

    def gradient(self, X, Y):
        # X: (m, n), Y: (m, k) one-hot
        m = X.shape[0]
        h = self.h_theta(X, self.W)              # (m, k)

        # Safe log to avoid log(0)
        eps = 1e-15
        h_safe = np.clip(h, eps, 1 - eps)

        # Average cross-entropy loss
        loss = -np.sum(Y * np.log(h_safe)) / m

        # Add regularization to the LOSS as well
        if self.regularization:
            loss += self.regularization(self.W) / m

        # Properly averaged gradient
        error = h - Y                             # (m, k)
        grad = (X.T @ error) / m                  # (n, k)

        # Add regularization to the GRAD
        if self.regularization:
            grad += self.regularization.derivation(self.W) / m
        return loss, grad

    def softmax(self, theta_t_x):
        theta_t_x = theta_t_x - np.max(theta_t_x, axis=1, keepdims=True)
        exp_scores = np.exp(theta_t_x)
        return exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

    def softmax_grad(self, X, error):
        return X.T @ error

    def h_theta(self, X, W):
        return self.softmax(X @ W)

    def predict(self, X_test):
        return np.argmax(self.h_theta(X_test, self.W), axis=1)

    def plot(self):
        plt.plot(np.arange(len(self.losses)), self.losses, label="Train Losses")
        plt.title("Losses")
        plt.xlabel("epoch")
        plt.ylabel("losses")
        plt.legend()

    def accuracy(self, y_test, y_pred):
        correct_predictions = np.sum(y_test == y_pred)
        total_predictions = y_test.shape[0]
        return correct_predictions / total_predictions

    def precision(self, y_test, y_pred, c=0):
        true_positives = np.sum((y_test == c) & (y_pred == c))
        false_positives = np.sum((y_test != c) & (y_pred == c))
        if true_positives + false_positives == 0:
            return 0
        else:
            return true_positives / (true_positives + false_positives)

    def recall(self, y_test, y_pred, c=0):

        true_positives = np.sum((y_test == c) & (y_pred == c))
        false_negatives = np.sum((y_test == c) & (y_pred != c))
        if true_positives + false_negatives == 0:
            return 0
        else:
            return true_positives / (true_positives + false_negatives)

    def f1_score(self, y_test, y_pred, c=0):

        precision = self.precision(y_test, y_pred, c)
        recall = self.recall(y_test, y_pred, c)
        if precision + recall == 0:
            return 0
        else:
            return 2 * precision * recall / (precision + recall)

    def macro_precision(self, y_test, y_pred):

        precisions = [self.precision(y_test, y_pred, c) for c in range(self.k)]
        return np.sum(precisions) / self.k

    def macro_recall(self, y_test, y_pred):

        recalls = [self.recall(y_test, y_pred, c) for c in range(self.k)]
        return np.sum(recalls) / self.k

    def macro_f1(self, y_test, y_pred):

        f1s = [self.f1_score(y_test, y_pred, c) for c in range(self.k)]
        return np.sum(f1s) / self.k

    def weighted_precision(self, y_test, y_pred):
  
        class_counts = [np.count_nonzero(y_test == c) for c in range(self.k)]
        precisions = [class_counts[c] / len(y_test) * self.precision(y_test, y_pred, c) for c in range(self.k)]
        return np.sum(precisions)

    def weighted_recall(self, y_test, y_pred):

        class_counts = [np.count_nonzero(y_test == c) for c in range(self.k)]
        recalls = [class_counts[c] / len(y_test) * self.recall(y_test, y_pred, c) for c in range(self.k)]
        return np.sum(recalls)

    def weighted_f1(self, y_test, y_pred):

        class_counts = [np.count_nonzero(y_test == c) for c in range(self.k)]
        f1s = [class_counts[c] / len(y_test) * self.f1_score(y_test, y_pred, c) for c in range(self.k)]
        return np.sum(f1s)

    def classification_report(self, y_test, y_pred):

        cols = ["precision", "recall", "f1-score"]
        idx = list(range(self.k)) + ["accuracy", "macro", "weighted"]

        report = [[self.precision(y_test, y_pred, c),
                   self.recall(y_test, y_pred, c),
                   self.f1_score(y_test, y_pred, c)] for c in range(self.k)]

        report.append(["", "", self.accuracy(y_test, y_pred)])

        report.append([self.macro_precision(y_test, y_pred),
                       self.macro_recall(y_test, y_pred),
                       self.macro_f1(y_test, y_pred)])

        report.append([self.weighted_precision(y_test, y_pred),
                       self.weighted_recall(y_test, y_pred),
                       self.weighted_f1(y_test, y_pred)])

        return pd.DataFrame(report, index=idx, columns=cols)

class RidgePenalty:

    def __init__(self, l):
        self.l = l

    def __call__(self, theta):
        return self.l * np.sum(np.square(theta))

    def derivation(self, theta):
        return self.l * 2 * theta

class Ridge(LogisticRegression):

    def __init__(self, l, k, n, method, alpha=0.001, max_iter=5000):
        regularization = RidgePenalty(l)
        super().__init__(regularization, k, n, method, alpha, max_iter)

class Normal(LogisticRegression):

    def __init__(self, k, n, method, alpha=0.001, max_iter=5000):
        super().__init__(regularization=None, k=k, n=n, method=method, alpha=alpha, max_iter=max_iter)

import sys

def str_to_class(classname):
    return getattr(sys.modules[__name__], classname)

regs = ["Normal", "Ridge"]
methods = ["batch", "minibatch", "sto"]
alphas = [0.01, 0.001, 0.0001]
best_model = None
best_train_loss = float('inf')
best_reg_name = ""
best_method = ""

for reg in regs:
    for method in methods:
        for alpha in alphas:
            if reg == "Normal":
                params = {"k": k, "n":X_train.shape[1], "method": method, "alpha": alpha, "max_iter": 10000}
            else:
                params = {"k": k, "n":X_train.shape[1], "method": method, "l": 0.1, "alpha": alpha, "max_iter": 10000}
            
            with mlflow.start_run(run_name=f"reg-{reg}-method-{params['method']}-alpha-{params['alpha']}"):
                print("="*30)
                print(reg, method)
                print(f"alpha: {alpha}")
                print("="*30)
                type_of_regression = str_to_class(reg)    #Normal, Ridge
                model = type_of_regression(**params)  
                model.fit(X_train, Y_train_encoded)
                yhat = model.predict(X_test)

                accuracy = model.accuracy(y_test, yhat)
                mlflow.log_metric(key="accuracy", value=accuracy)

                for c in range(k):
                    f1 = model.f1_score(y_test, yhat, c)
                    precision = model.precision(y_test, yhat, c)
                    recall = model.recall(y_test, yhat, c)
                    mlflow.log_metric(key=f"class_{c}_f1", value=f1)
                    mlflow.log_metric(key=f"class_{c}_recall", value=recall)
                    mlflow.log_metric(key=f"class_{c}_precision", value=precision)
                
                # Get the final training loss
                final_train_loss = model.losses[-1]
                print(f"Final Training Loss: {final_train_loss}")
                
                # Compare the current model's training loss with the best so far
                if final_train_loss < best_train_loss:
                    best_train_loss = final_train_loss
                    best_model = model
                    best_reg_name = reg
                    best_method = method

                signature = mlflow.models.infer_signature(X_train, model.predict(X_train))
                mlflow.sklearn.log_model(model, name='model', signature=signature)                

        mlflow.end_run()

mlflow.end_run()

==============================
Normal batch
alpha: 0.01
==============================
Loss at iteration 0 6.917298901322403
Loss at iteration 500 1.0143461901860302
Loss at iteration 1000 0.9299357607137992
Loss at iteration 1500 0.8909880660457434
Loss at iteration 2000 0.8679449034338557
Loss at iteration 2500 0.8526838356632752
Loss at iteration 3000 0.8418716310023614
Loss at iteration 3500 0.8338574077618752
Loss at iteration 4000 0.8277225033431471
Loss at iteration 4500 0.8229118746927121
Loss at iteration 5000 0.8190688430941218
Loss at iteration 5500 0.8159529980620436
Loss at iteration 6000 0.8133960640651283
Loss at iteration 6500 0.8112766220748742
Loss at iteration 7000 0.8095048551949441
Loss at iteration 7500 0.8080129341883356
Loss at iteration 8000 0.8067487321002725
Loss at iteration 8500 0.8056715861081603
Loss at iteration 9000 0.8047493633401864
Loss at iteration 9500 0.8039563827846886
time taken: 14.303831815719604
Final Training Loss: 0.8032731865964094

2025/10/04 14:07:37 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.

🏃 View run reg-Normal-method-batch-alpha-0.01 at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080/runs/bd618604107f4c2e9686925cd8cda407
🧪 View experiment at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080
==============================
Normal batch
alpha: 0.001
==============================
Loss at iteration 0 4.429272435394426
Loss at iteration 500 1.534130239198065
Loss at iteration 1000 1.4005921487978101
Loss at iteration 1500 1.302760724965179
Loss at iteration 2000 1.2315492381861748
Loss at iteration 2500 1.1786696375458574
Loss at iteration 3000 1.1381853902575918
Loss at iteration 3500 1.1062127047223258
Loss at iteration 4000 1.080252926031754
Loss at iteration 4500 1.0586746260617226
Loss at iteration 5000 1.040384408786265
Loss at iteration 5500 1.0246280018423528
Loss at iteration 6000 1.0108702157951959
Loss at iteration 6500 0.9987212490219259
Loss at iteration 7000 0.9878903632365262
Loss at iteration 7500 0.9781560191771285
Loss at iteration 8000 0.9693461399816586
Loss at iteration 8500 0.9613247572044875
Loss at iteration 9000 0.9539827749314705
Loss at iteration 9500 0.9472314509276526
time taken: 14.081402063369751
Final Training Loss: 0.9410097014802694

2025/10/04 14:08:05 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.

🏃 View run reg-Normal-method-batch-alpha-0.001 at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080/runs/edfdcc682ebc4a199bdd9b9f1eed38d4
🧪 View experiment at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080
==============================
Normal batch
alpha: 0.0001
==============================
Loss at iteration 0 5.0628310515969295
Loss at iteration 500 1.7056071149785714
Loss at iteration 1000 1.1866432517143946
Loss at iteration 1500 1.1767684860473273
Loss at iteration 2000 1.1718215540936037
Loss at iteration 2500 1.167012482893219
Loss at iteration 3000 1.1623339018576175
Loss at iteration 3500 1.1577813558379917
Loss at iteration 4000 1.153350517623576
Loss at iteration 4500 1.1490371885658002
Loss at iteration 5000 1.144837299683124
Loss at iteration 5500 1.1407469120111862
Loss at iteration 6000 1.1367622162772821
Loss at iteration 6500 1.1328795319768201
Loss at iteration 7000 1.129095305927807
Loss at iteration 7500 1.1254061103763546
Loss at iteration 8000 1.1218086407221328
Loss at iteration 8500 1.1182997129278134
Loss at iteration 9000 1.1148762606712612
Loss at iteration 9500 1.1115353322937134
time taken: 14.099228858947754
Final Training Loss: 1.1082805323903167

2025/10/04 14:08:34 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.

🏃 View run reg-Normal-method-batch-alpha-0.0001 at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080/runs/4d59a5bf5c05477b87537b11d8eae5c4
🧪 View experiment at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080
==============================
Normal minibatch
alpha: 0.01
==============================
Loss at iteration 0 10.90744479868169
Loss at iteration 500 1.0280713938704982
Loss at iteration 1000 0.9420780019301521
Loss at iteration 1500 0.8813364847869282
Loss at iteration 2000 0.8558070443586259
Loss at iteration 2500 0.8724673320679531
Loss at iteration 3000 0.8454954103973392
Loss at iteration 3500 0.829464357592458
Loss at iteration 4000 0.8200245059245889
Loss at iteration 4500 0.8368025014831096
Loss at iteration 5000 0.7970344245365778
Loss at iteration 5500 0.7975979653151596
Loss at iteration 6000 0.799381161793619
Loss at iteration 6500 0.833872777050089
Loss at iteration 7000 0.7750621982265061
Loss at iteration 7500 0.8113207171798568
Loss at iteration 8000 0.7958638274609966
Loss at iteration 8500 0.8224639221132657
Loss at iteration 9000 0.8107879424142306
Loss at iteration 9500 0.7997750259381546
time taken: 12.293530225753784
Final Training Loss: 0.8089428695173724

2025/10/04 14:09:00 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.

🏃 View run reg-Normal-method-minibatch-alpha-0.01 at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080/runs/affa6ea96a9a4b42938895d7753ae526
🧪 View experiment at: https://mlflow.ml.brain.cs.ait.ac.th/#/experiments/442617570942485080
==============================
Normal minibatch
alpha: 0.001
==============================
Loss at iteration 0 5.1327979154524686
Loss at iteration 500 1.33286152545923
Loss at iteration 1000 1.2489763741118283
Loss at iteration 1500 1.1936696647700564
Loss at iteration 2000 1.137996961887521
Loss at iteration 2500 1.131040962250183
Loss at iteration 3000 1.0822537662146994
Loss at iteration 3500 1.067433342213668
Loss at iteration 4000 1.051521771790507
Loss at iteration 4500 1.0113901585865508
Loss at iteration 5000 1.032100504452786
Loss at iteration 5500 1.013592178578278
Loss at iteration 6000 0.999784961744841
Loss at iteration 6500 0.9952340065221146
Loss at iteration 7000 0.9765744215897627
Loss at iteration 7500 0.9460504690716921
Loss at iteration 8000 0.9760493170071984
Loss at iteration 8500 0.9380624917557167
Loss at iteration 9000 0.9515891635940661
Loss at iteration 9500 0.9441968633966522
time taken: 12.551079988479614
Final Training Loss: 0.9230023533309908

2025/10/04 14:09:27 WARNING mlflow.utils.environment: Failed to resolve installed pip version. ``pip`` will be added to conda.yaml environment spec without a version specifier.

# Plotting the loss graph the graph of the best model
print("Best Model:")
print(f"Regularization: {best_reg_name}")
print(f"Method: {best_method}")
print(f"Final Training Loss: {best_train_loss}")
best_model.plot()
plt.show()

Best Model:
Regularization: Normal
Method: sto
Final Training Loss: 5.601577689611762e-07

from sklearn.metrics import classification_report as sklearn_classification_report

# Assuming best_model is already defined based on the previous code

# Use the best model to predict
yhat = best_model.predict(X_test)

# Custom classification report
custom_classification_report = best_model.classification_report(y_test, yhat)
print("*" * 5, "Custom Classification report", "*" * 5)
print(custom_classification_report)

# Sklearn's classification report
sklearn_report = sklearn_classification_report(y_test, yhat)
print("\n")
print("*" * 5, "Sklearn's Classification report", "*" * 5)
print(sklearn_report)

***** Custom Classification report *****
         precision    recall  f1-score
0         0.782828   0.72205  0.751212
1         0.494413  0.282748  0.359756
2              0.5  0.001767  0.003521
3         0.394231       1.0  0.565517
accuracy                      0.504979
macro     0.542868  0.501641  0.420002
weighted  0.548935  0.504979  0.429704


***** Sklearn's Classification report *****
              precision    recall  f1-score   support

           0       0.78      0.72      0.75       644
           1       0.49      0.28      0.36       626
           2       0.50      0.00      0.00       566
           3       0.39      1.00      0.57       574

    accuracy                           0.50      2410
   macro avg       0.54      0.50      0.42      2410
weighted avg       0.55      0.50      0.43      2410

import pickle

filename = 'Model/A3_car_prediction.model'
pickle.dump(model, open(filename, 'wb'))

scaler_path = 'Model/A3_prediction_scalar.model'
pickle.dump(scaler, open(scaler_path, 'wb'))

label_path = 'Model/A3_brand_label.model'
pickle.dump(original_brands, open(label_path, 'wb'))

print(model)

<ModelVersion: aliases=[], creation_timestamp=1759571825827, current_stage='None', deployment_job_state=<ModelVersionDeploymentJobState: current_task_name='', job_id='', job_state='DEPLOYMENT_JOB_CONNECTION_STATE_UNSPECIFIED', run_id='', run_state='DEPLOYMENT_JOB_RUN_STATE_UNSPECIFIED'>, description='', last_updated_timestamp=1759571825827, metrics=None, model_id=None, name='st126222-a3-model', params=None, run_id='affa6ea96a9a4b42938895d7753ae526', run_link='', source='models:/m-31174258c90242009ca0654a2dcdf5e3', status='READY', status_message=None, tags={}, user_id='', version='1'>

## Registering the model with best run id
import mlflow
from mlflow.tracking import MlflowClient

# MLflow client
client = MlflowClient()

# Your new model name
model_name = "st126222-a3-model"

# Best run info
best_run_id = "affa6ea96a9a4b42938895d7753ae526"
model_uri = f"runs:/{best_run_id}/model"  # Assuming your model artifact is saved under "model"

# Check if the model already exists and delete if needed
try:
    client.delete_registered_model(name=model_name)
    print(f"Deleted existing registered model '{model_name}'")
except Exception as e:
    print(f"No existing model to delete or error: {e}")

# Register the new model
registered_model = mlflow.register_model(model_uri=model_uri, name=model_name)
print(f"Registered new model '{model_name}' with version: {registered_model.version}")

Deleted existing registered model 'st126222-a3-model'

Successfully registered model 'st126222-a3-model'.
2025/10/04 16:57:11 WARNING mlflow.tracking._model_registry.fluent: Run with id affa6ea96a9a4b42938895d7753ae526 has no artifacts at artifact path 'model', registering model based on models:/m-31174258c90242009ca0654a2dcdf5e3 instead
2025/10/04 16:57:11 INFO mlflow.store.model_registry.abstract_store: Waiting up to 300 seconds for model version to finish creation. Model name: st126222-a3-model, version 1
Created version '1' of model 'st126222-a3-model'.

Registered new model 'st126222-a3-model' with version: 1

from mlflow.tracking import MlflowClient
import time

client = MlflowClient()
model_name = "st126222-a3-model"
version = 1   # whichever version you just registered

while True:
    mv = client.get_model_version(name=model_name, version=version)
    print(f"Version {version} status: {mv.status}")
    if mv.status == "READY":
        print("✅ Model is READY to use!")
        break
    elif mv.status == "FAILED_REGISTRATION":
        print("❌ Model failed to register")
        break
    else:
        print("⏳ Still waiting...")
        time.sleep(2)

Version 1 status: READY
✅ Model is READY to use!

from mlflow.tracking import MlflowClient

client = MlflowClient()
for model in client.get_registered_model("st126222-a3-model").latest_versions:
    print(model)
    #Find model in staging

    if(model.current_stage == "Staging"):
        version = model.version
        client.transition_model_version_stage(
            name="st126222-a3-model", version = version, stage= "Production", archive_existing_versions= True
        )

<ModelVersion: aliases=[], creation_timestamp=1759571825827, current_stage='None', deployment_job_state=<ModelVersionDeploymentJobState: current_task_name='', job_id='', job_state='DEPLOYMENT_JOB_CONNECTION_STATE_UNSPECIFIED', run_id='', run_state='DEPLOYMENT_JOB_RUN_STATE_UNSPECIFIED'>, description='', last_updated_timestamp=1759571825827, metrics=None, model_id=None, name='st126222-a3-model', params=None, run_id='affa6ea96a9a4b42938895d7753ae526', run_link='', source='models:/m-31174258c90242009ca0654a2dcdf5e3', status='READY', status_message=None, tags={}, user_id='', version='1'>

from mlflow.tracking import MlflowClient

client = MlflowClient()

# Promote version 1 of your model to Production
client.transition_model_version_stage(
    name="st126222-a3-model",
    version=1,
    stage="Production",
    archive_existing_versions=True
)

print("🚀 Model promoted to Production!")

---------------------------------------------------------------------------
ResponseError                             Traceback (most recent call last)
ResponseError: too many 500 error responses

The above exception was the direct cause of the following exception:

MaxRetryError                             Traceback (most recent call last)
File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/requests/adapters.py:644, in HTTPAdapter.send(self, request, stream, timeout, verify, cert, proxies)
    643 try:
--> 644     resp = conn.urlopen(
    645         method=request.method,
    646         url=url,
    647         body=request.body,
    648         headers=request.headers,
    649         redirect=False,
    650         assert_same_host=False,
    651         preload_content=False,
    652         decode_content=False,
    653         retries=self.max_retries,
    654         timeout=timeout,
    655         chunked=chunked,
    656     )
    658 except (ProtocolError, OSError) as err:

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:942, in HTTPConnectionPool.urlopen(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)
    941     log.debug("Retry: %s", url)
--> 942     return self.urlopen(
    943         method,
    944         url,
    945         body,
    946         headers,
    947         retries=retries,
    948         redirect=redirect,
    949         assert_same_host=assert_same_host,
    950         timeout=timeout,
    951         pool_timeout=pool_timeout,
    952         release_conn=release_conn,
    953         chunked=chunked,
    954         body_pos=body_pos,
    955         preload_content=preload_content,
    956         decode_content=decode_content,
    957         **response_kw,
    958     )
    960 return response

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:942, in HTTPConnectionPool.urlopen(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)
    941     log.debug("Retry: %s", url)
--> 942     return self.urlopen(
    943         method,
    944         url,
    945         body,
    946         headers,
    947         retries=retries,
    948         redirect=redirect,
    949         assert_same_host=assert_same_host,
    950         timeout=timeout,
    951         pool_timeout=pool_timeout,
    952         release_conn=release_conn,
    953         chunked=chunked,
    954         body_pos=body_pos,
    955         preload_content=preload_content,
    956         decode_content=decode_content,
    957         **response_kw,
    958     )
    960 return response

    [... skipping similar frames: HTTPConnectionPool.urlopen at line 942 (4 times)]

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:942, in HTTPConnectionPool.urlopen(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)
    941     log.debug("Retry: %s", url)
--> 942     return self.urlopen(
    943         method,
    944         url,
    945         body,
    946         headers,
    947         retries=retries,
    948         redirect=redirect,
    949         assert_same_host=assert_same_host,
    950         timeout=timeout,
    951         pool_timeout=pool_timeout,
    952         release_conn=release_conn,
    953         chunked=chunked,
    954         body_pos=body_pos,
    955         preload_content=preload_content,
    956         decode_content=decode_content,
    957         **response_kw,
    958     )
    960 return response

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:932, in HTTPConnectionPool.urlopen(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)
    931 try:
--> 932     retries = retries.increment(method, url, response=response, _pool=self)
    933 except MaxRetryError:

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/urllib3/util/retry.py:519, in Retry.increment(self, method, url, response, error, _pool, _stacktrace)
    518     reason = error or ResponseError(cause)
--> 519     raise MaxRetryError(_pool, url, reason) from reason  # type: ignore[arg-type]
    521 log.debug("Incremented Retry for (url='%s'): %r", url, new_retry)

MaxRetryError: HTTPSConnectionPool(host='mlflow.ml.brain.cs.ait.ac.th', port=443): Max retries exceeded with url: /api/2.0/mlflow/model-versions/transition-stage (Caused by ResponseError('too many 500 error responses'))

During handling of the above exception, another exception occurred:

RetryError                                Traceback (most recent call last)
File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/utils/rest_utils.py:230, in http_request(host_creds, endpoint, method, max_retries, backoff_factor, backoff_jitter, extra_headers, retry_codes, timeout, raise_on_status, respect_retry_after_header, retry_timeout_seconds, **kwargs)
    229 try:
--> 230     return _get_http_response_with_retries(
    231         method,
    232         url,
    233         max_retries,
    234         backoff_factor,
    235         backoff_jitter,
    236         retry_codes,
    237         raise_on_status,
    238         headers=headers,
    239         verify=host_creds.verify,
    240         timeout=timeout,
    241         respect_retry_after_header=respect_retry_after_header,
    242         **kwargs,
    243     )
    244 except requests.exceptions.Timeout as to:

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/utils/request_utils.py:237, in _get_http_response_with_retries(method, url, max_retries, backoff_factor, backoff_jitter, retry_codes, raise_on_status, allow_redirects, respect_retry_after_header, **kwargs)
    235 allow_redirects = env_value if allow_redirects is None else allow_redirects
--> 237 return session.request(method, url, allow_redirects=allow_redirects, **kwargs)

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/requests/sessions.py:589, in Session.request(self, method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, verify, cert, json)
    588 send_kwargs.update(settings)
--> 589 resp = self.send(prep, **send_kwargs)
    591 return resp

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/requests/sessions.py:703, in Session.send(self, request, **kwargs)
    702 # Send the request
--> 703 r = adapter.send(request, **kwargs)
    705 # Total elapsed time of the request (approximately)

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/requests/adapters.py:668, in HTTPAdapter.send(self, request, stream, timeout, verify, cert, proxies)
    667 if isinstance(e.reason, ResponseError):
--> 668     raise RetryError(e, request=request)
    670 if isinstance(e.reason, _ProxyError):

RetryError: HTTPSConnectionPool(host='mlflow.ml.brain.cs.ait.ac.th', port=443): Max retries exceeded with url: /api/2.0/mlflow/model-versions/transition-stage (Caused by ResponseError('too many 500 error responses'))

During handling of the above exception, another exception occurred:

MlflowException                           Traceback (most recent call last)
Cell In[493], line 6
      3 client = MlflowClient()
      5 # Promote version 1 of your model to Production
----> 6 client.transition_model_version_stage(
      7     name="st126222-a3-model",
      8     version=1,
      9     stage="Production",
     10     archive_existing_versions=True
     11 )
     13 print("🚀 Model promoted to Production!")

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/utils/annotations.py:186, in deprecated.<locals>.deprecated_decorator.<locals>.deprecated_func(*args, **kwargs)
    183 @wraps(obj)
    184 def deprecated_func(*args, **kwargs):
    185     warnings.warn(notice, category=FutureWarning, stacklevel=2)
--> 186     return obj(*args, **kwargs)

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/tracking/client.py:4595, in MlflowClient.transition_model_version_stage(self, name, version, stage, archive_existing_versions)
   4523 """
   4524 Update model version stage.
   4525 
   (...)   4592     Stage: Staging
   4593 """
   4594 self._raise_if_prompt(name)
-> 4595 return self._get_registry_client().transition_model_version_stage(
   4596     name, version, stage, archive_existing_versions
   4597 )

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/tracking/_model_registry/client.py:332, in ModelRegistryClient.transition_model_version_stage(self, name, version, stage, archive_existing_versions)
    330 if stage.strip() == "":
    331     raise MlflowException("The stage must not be an empty string.")
--> 332 return self.store.transition_model_version_stage(
    333     name=name,
    334     version=version,
    335     stage=stage,
    336     archive_existing_versions=archive_existing_versions,
    337 )

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/store/model_registry/rest_store.py:329, in RestStore.transition_model_version_stage(self, name, version, stage, archive_existing_versions)
    305 """
    306 Update model version stage.
    307 
   (...)    319 
    320 """
    321 req_body = message_to_json(
    322     TransitionModelVersionStage(
    323         name=name,
   (...)    327     )
    328 )
--> 329 response_proto = self._call_endpoint(TransitionModelVersionStage, req_body)
    330 return ModelVersion.from_proto(response_proto.model_version)

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/store/model_registry/base_rest_store.py:42, in BaseRestStore._call_endpoint(self, api, json_body, call_all_endpoints, extra_headers)
     40 else:
     41     endpoint, method = self._get_endpoint_from_method(api)
---> 42     return call_endpoint(
     43         self.get_host_creds(), endpoint, method, json_body, response_proto, extra_headers
     44     )

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/utils/rest_utils.py:552, in call_endpoint(host_creds, endpoint, method, json_body, response_proto, extra_headers, retry_timeout_seconds)
    550 else:
    551     call_kwargs["json"] = json_body
--> 552     response = http_request(**call_kwargs)
    554 response = verify_rest_response(response, endpoint)
    555 response_to_parse = response.text

File ~/Library/CloudStorage/OneDrive-AsianInstituteofTechnology/AIT/Machine_Learning/A3/.venv/lib/python3.12/site-packages/mlflow/utils/rest_utils.py:253, in http_request(host_creds, endpoint, method, max_retries, backoff_factor, backoff_jitter, extra_headers, retry_codes, timeout, raise_on_status, respect_retry_after_header, retry_timeout_seconds, **kwargs)
    251     raise InvalidUrlException(f"Invalid url: {url}") from iu
    252 except Exception as e:
--> 253     raise MlflowException(f"API request to {url} failed with exception {e}")

MlflowException: API request to https://mlflow.ml.brain.cs.ait.ac.th/api/2.0/mlflow/model-versions/transition-stage failed with exception HTTPSConnectionPool(host='mlflow.ml.brain.cs.ait.ac.th', port=443): Max retries exceeded with url: /api/2.0/mlflow/model-versions/transition-stage (Caused by ResponseError('too many 500 error responses'))

# Best run id
run_id = "affa6ea96a9a4b42938895d7753ae526"

# Build the model URI (artifact path was "model" when you logged it)
model_uri = f"runs:/{run_id}/model"

# Load the model
model = mlflow.pyfunc.load_model(model_uri)

print(type(model))

<class 'mlflow.pyfunc.PyFuncModel'>

import pandas as pd
precited_selling_price= model.predict(pd.DataFrame(X_test))
precited_selling_price[:10]

array([2, 2, 2, 1, 3, 2, 3, 3, 3, 1])

y_test[:10]

array([2, 2, 1, 1, 3, 1, 2, 3, 1, 3])

sample_df = pd.DataFrame([[107, 100,2017, 'BMW']],
                         columns=['max_power', 'mileage', 'year', 'brand'])
sample_df

sample_df['brand'] = label_encoder_brand.transform(sample_df['brand'])

sample_df

sample_df = sample_df.astype("float64")
output = model.predict(sample_df)
print(output)

[3]

import base64
from IPython.display import display, HTML

# List all the image filenames
image_files = [
    "../images/MLflow1.png",
    "../images/MLflow2.png",
    "../images/Deploy1.png",
    "../images/Deploy3.png",
    "../images/Deploy4.png",
    "../images/Deploy5.png"
]

# Generate base64 <img> tags and display them one by one
html_images = ""
for path in image_files:
    with open(path, "rb") as f:
        data = base64.b64encode(f.read()).decode()
    name = path.split("/")[-1].split(".")[0]
    html_images += f'<img src="data:image/png;base64,{data}" alt="{name}" width="700" style="margin:10px 0;"/><br>'

# Display all images in the notebook
display(HTML(html_images))

	year	selling_price	km_driven	seats
count	8128.000000	8.128000e+03	8.128000e+03	7907.000000
mean	2013.804011	6.382718e+05	6.981951e+04	5.416719
std	4.044249	8.062534e+05	5.655055e+04	0.959588
min	1983.000000	2.999900e+04	1.000000e+00	2.000000
25%	2011.000000	2.549990e+05	3.500000e+04	5.000000
50%	2015.000000	4.500000e+05	6.000000e+04	5.000000
75%	2017.000000	6.750000e+05	9.800000e+04	5.000000
max	2020.000000	1.000000e+07	2.360457e+06	14.000000

Metric	Value
Accuracy	0.6162
Training Loss	0.7998
Class 0 Precision	0.7576
Class 0 F1-Score	0.7669
Class 2 F1-Score	0.4751

A3 - Predicting Car Prices

Task 1: Preparing the datasets

Exploratory Data Analysis

Univariate Analysis

Multivariate Analysis

Correlation matrix

Feature Selection

Data Splitting

Preprocessing

Finding the mean, median, and mode of the features to fill up the null values

Filling the missing numerical values

Checking for outliers

Scaling the dataset

Report

Feature Selection

Changing selling price to discrete values

Models

Model Training and Evaluation

Best Model from MLflow Tracking

Screenshots

	name	year	selling_price	km_driven	fuel	seller_type	transmission	owner	mileage	engine	max_power	torque	seats
0	Maruti Swift Dzire VDI	2014	450000	145500	Diesel	Individual	Manual	First Owner	23.4 kmpl	1248 CC	74 bhp	190Nm@ 2000rpm	5.0
1	Skoda Rapid 1.5 TDI Ambition	2014	370000	120000	Diesel	Individual	Manual	Second Owner	21.14 kmpl	1498 CC	103.52 bhp	250Nm@ 1500-2500rpm	5.0
2	Honda City 2017-2020 EXi	2006	158000	140000	Petrol	Individual	Manual	Third Owner	17.7 kmpl	1497 CC	78 bhp	12.7@ 2,700(kgm@ rpm)	5.0
3	Hyundai i20 Sportz Diesel	2010	225000	127000	Diesel	Individual	Manual	First Owner	23.0 kmpl	1396 CC	90 bhp	22.4 kgm at 1750-2750rpm	5.0
4	Maruti Swift VXI BSIII	2007	130000	120000	Petrol	Individual	Manual	First Owner	16.1 kmpl	1298 CC	88.2 bhp	11.5@ 4,500(kgm@ rpm)	5.0

	brand	year	selling_price	km_driven	fuel	seller_type	transmission	owner	mileage	engine	max_power	seats
0	Maruti	2014	450000	145500	Diesel	Individual	Manual	1	23.40	1248.0	74.00	5.0
1	Skoda	2014	370000	120000	Diesel	Individual	Manual	2	21.14	1498.0	103.52	5.0
2	Honda	2006	158000	140000	Petrol	Individual	Manual	3	17.70	1497.0	78.00	5.0
3	Hyundai	2010	225000	127000	Diesel	Individual	Manual	1	23.00	1396.0	90.00	5.0
4	Maruti	2007	130000	120000	Petrol	Individual	Manual	1	16.10	1298.0	88.20	5.0